"""
Redis 客户端和缓存管理（使用连接池）
"""

import json
from typing import Optional, List, Dict
from uuid import UUID

import redis
from app.config import get_settings

settings = get_settings()

# 解析 Redis URL

# 创建 Redis 连接池
redis_pool = redis.ConnectionPool(
    host=settings.REDIS_HOST,
    port=settings.REDIS_PORT,
    db=0,
    password=settings.REDIS_PASSWORD,
    decode_responses=True,
    max_connections=10,  # 最大连接数
    socket_connect_timeout=5,
    socket_timeout=5,
)

# 创建 Redis 客户端（使用连接池）
redis_client = redis.Redis(connection_pool=redis_pool)


class ChatHistoryCache:
    """聊天历史缓存管理器"""

    @staticmethod
    def _get_key(session_id: UUID) -> str:
        """生成 Redis 键"""
        return f"history:{str(session_id)}"

    @staticmethod
    def get(session_id: UUID) -> Optional[List[Dict[str, str]]]:
        """
        从 Redis 获取聊天历史

        Args:
            session_id: 会话 ID

        Returns:
            Optional[List[Dict]]: 聊天历史列表，如果不存在则返回 None
        """
        key = ChatHistoryCache._get_key(session_id)
        data = redis_client.get(key)

        if data:
            return json.loads(data)

        return None

    @staticmethod
    def set(
        session_id: UUID, history: List[Dict[str, str]], expire: int = 3600
    ) -> None:
        """
        将聊天历史存入 Redis

        Args:
            session_id: 会话 ID
            history: 聊天历史列表
            expire: 过期时间（秒），默认 1 小时
        """
        key = ChatHistoryCache._get_key(session_id)
        redis_client.setex(key, expire, json.dumps(history, ensure_ascii=False))

    @staticmethod
    def delete(session_id: UUID) -> None:
        """
        删除聊天历史缓存

        Args:
            session_id: 会话 ID
        """
        key = ChatHistoryCache._get_key(session_id)
        redis_client.delete(key)

    @staticmethod
    def append_message(
        session_id: UUID,
        role: str,
        content: str,
        tool_name: Optional[str] = None,
        is_internal: bool = False,
    ) -> None:
        """
        追加消息到缓存（支持工具消息）

        Args:
            session_id: 会话 ID
            role: 角色（human, ai, tool, tool_result）
            content: 消息内容
            tool_name: 工具名称（可选，仅用于tool和tool_result）
            is_internal: 是否为内部消息（工具调用），默认False
        """
        history = ChatHistoryCache.get(session_id) or []
        message = {"role": role, "content": content, "is_internal": is_internal}
        if tool_name:
            message["tool_name"] = tool_name
        history.append(message)
        ChatHistoryCache.set(session_id, history)


def test_redis_connection() -> bool:
    """
    测试 Redis 连接

    Returns:
        bool: 连接是否成功
    """
    try:
        redis_client.ping()
        return True
    except Exception:
        return False


def get_redis_info() -> dict:
    """
    获取 Redis 信息（用于调试）

    Returns:
        dict: Redis 服务器信息
    """
    try:
        info = redis_client.info()
        return {
            "connected": True,
            "version": info.get("redis_version"),
            "used_memory": info.get("used_memory_human"),
            "connected_clients": info.get("connected_clients"),
        }
    except Exception as e:
        return {"connected": False, "error": str(e)}
